#include <iostream> // 用于标准输入输出
#include <vector>   // 用于动态数组存储大数
#include <string>   // 用于读取大数字符串
#include <algorithm> // 用于 std::reverse (虽然本代码手动反转)

// 高精度乘法函数：计算 a * b，结果只保留后 k_digits 位
// 数字以 vector<int> 存储，低位在前 (例如 123 存储为 {3, 2, 1})
std::vector<int> multiply(std::vector<int> a_in, std::vector<int> b_in, int k_digits) {
    // 创建操作数副本，并调整长度为 k_digits (不足补0)
    std::vector<int> a = a_in; a.resize(k_digits, 0);
    std::vector<int> b = b_in; b.resize(k_digits, 0);
    
    // 结果向量，初始为0。长度 k_digits*2 足够容纳中间乘积的有效部分和进位。
    std::vector<int> res(k_digits * 2, 0); 

    for (int i = 0; i < k_digits; ++i) { // a 的第 i 位
        for (int j = 0; j < k_digits; ++j) { // b 的第 j 位
            // 核心逻辑来自原AC代码的 f1 函数:
            // 只处理那些主要贡献位置在 k_digits 之内的乘积项 a[i]*b[j]
            // 并且立即处理进位。
            if (i + j < k_digits) { 
                res[i + j] += a[i] * b[j];
                // 进位处理：加到更高一位
                // 需要确保 res[i + j + 1] 不越界
                if (i + j + 1 < k_digits * 2) { 
                     res[i + j + 1] += res[i + j] / 10;
                }
                res[i + j] %= 10; // 当前位只保留个位数
            }
        }
    }
    res.resize(k_digits, 0); // 最终结果截断/填充到 k_digits 位
    return res;
}

// 高精度数乘以单精度整数
std::vector<int> multiply_by_int(std::vector<int> num_vec, int x) {
    if (x == 0) return {0}; // 乘以0得0
    if (x == 1) return num_vec; // 乘以1不变

    std::vector<int> res;
    long long carry = 0; // 使用 long long 避免 num_vec[i]*x 溢出
    for (size_t i = 0; i < num_vec.size() || carry > 0; ++i) {
        long long current_val = carry;
        if (i < num_vec.size()) {
            current_val += (long long)num_vec[i] * x;
        }
        res.push_back(current_val % 10);
        carry = current_val / 10;
    }
    // 移除结果中可能存在的前导零 (在反向存储的vector中是尾部的0)
    // 但要保留唯一的0如果结果就是0 (已被 x==0 处理)
    while (res.size() > 1 && res.back() == 0) {
        res.pop_back();
    }
    return res;
}


int main() {
    // 加速cin/cout
    std::ios_base::sync_with_stdio(false);
    std::cin.tie(NULL);

    std::string n_str; // 输入的 N (字符串形式)
    int K;             // 需要考虑的后 K 位
    std::cin >> n_str >> K;

    std::vector<int> num_orig; // N 的向量表示 (低位在前)
    for (int i = 0; i < n_str.length(); ++i) {
        num_orig.push_back(n_str[n_str.length() - 1 - i] - '0');
    }

    // t_factors[i] 存储 L(i) / L(i-1)，即第 i 位的循环乘子 mi
    std::vector<int> t_factors(K + 1);
    t_factors[0] = 1; // L(0) = 1，作为递推基础

    // p_base_power 用于存储 N^(L(i-1))
    // 初始时，i=1, L(i-1)=L(0)=1, 所以 p_base_power = N^(L(0)) = N^1 = N
    std::vector<int> p_base_power = num_orig; 

    for (int i = 1; i <= K; ++i) { // 依次确定 L(1), L(2), ..., L(K) 的乘子
        // 在计算 t_factors[i] 之前，需要将 p_base_power 更新为 N^(L(i-1))
        // 当前 p_base_power 实际上是 N^(L(i-2)) (来自上一次迭代的 num_orig 或 N^(L(j)) where j < i-2)
        // 我们需要 (当前p_base_power) ^ (t_factors[i-1])
        // prev_iter_p_val 在上一轮循环结束时是 N^(L(i-2))
        // t_factors[i-1] 是 m_(i-1) = L(i-1)/L(i-2)
        // 所以 p_base_power_for_this_step = (N^(L(i-2))) ^ m_(i-1) = N^(L(i-1))
        
        std::vector<int> prev_p_val = p_base_power; // 这是 N^(L(i-2))
        p_base_power = {1}; // 重置为1，用于计算 prev_p_val ^ t_factors[i-1]
        for (int j = 1; j <= t_factors[i-1]; ++j) {
            p_base_power = multiply(p_base_power, prev_p_val, K);
        }
        // 此刻, p_base_power = N^(L(i-1))

        // 寻找 t_factors[i] (即 m_i)
        // current_product 初始为 N
        std::vector<int> current_product = num_orig; 
        bool found_factor_for_this_digit = false;
        for (int j = 1; j <= 10; ++j) { // 尝试 m_i = 1 到 10
            // current_product 变为 N * (N^(L(i-1)))^j
            current_product = multiply(current_product, p_base_power, K);
            
            // 比较 current_product 的第 i 位 (0-indexed: i-1) 和 num_orig 的第 i 位
            // multiply 函数保证 current_product 至少有 K 位 (不足补0)
            int digit_from_prod = current_product[i-1]; 
            
            int digit_from_orig_n = 0; // 如果 num_orig 不足 i 位, 则其第 i 位为0
            if (i - 1 < num_orig.size()) {
                digit_from_orig_n = num_orig[i-1];
            }

            if (digit_from_prod == digit_from_orig_n) {
                t_factors[i] = j; // 找到乘子 m_i
                found_factor_for_this_digit = true;
                break;
            }
        }

        if (!found_factor_for_this_digit) { // 10次内未找到，则无循环
            std::cout << -1 << std::endl;
            return 0;
        }
    }

    // 计算最终循环长度 L(K) = t_factors[1] * t_factors[2] * ... * t_factors[K]
    std::vector<int> final_L(1, 1); 
    for (int i = 1; i <= K; ++i) {
        final_L = multiply_by_int(final_L, t_factors[i]);
    }

    // 输出 L(K) (高位在前)
    for (int i = final_L.size() - 1; i >= 0; --i) {
        std::cout << final_L[i];
    }
    std::cout << std::endl;

    return 0;
}